package com.topcent.tioxyc.controller;

import cn.hutool.core.date.DateTime;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.topcent.tioxyc.constants.KeyConstant;
import com.topcent.tioxyc.mapper.Yy1KpiMapper;
import com.topcent.tioxyc.pojo.SalesOrder;
import com.topcent.tioxyc.pojo.SalesOrderSql;
import com.topcent.tioxyc.pojo.vo.ToChangeVO;
import com.topcent.tioxyc.util.ApiClient;
import com.topcent.tioxyc.util.ConnmeUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.ListUtils;
import org.apache.http.Header;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author: 陈百万
 * @date: 2025/6/5 15:39
 * @Description: 按条件筛选销售订单数据到sql数据库
 */
@Slf4j
@RestController
public class CcAddSalesOrderToSqlController {
    @Autowired
    private Yy1KpiMapper yy1KpiMapper;

    @GetMapping("addSalesOrderToSql")
    public String addSalesOrderToSql() {
        List<SalesOrder> salesOrderList = new ArrayList<>();
        Header[] headers = ConnmeUtils.createHeaders();
        Map<String, Object> parameter = new HashMap<>();
        parameter.put("app_id", "667230ad22a8581756b77d52");
        parameter.put("entry_id", "667230b322a8581756b78353");

        Map<String, Object> filter = new HashMap<>();
        filter.put("rel", "and");
        Map<String, Object> cond = new HashMap<>();
        cond.put("field", "flowState");
        cond.put("type", "flowstate");
        cond.put("method", "eq");
        List<Integer> values = new ArrayList<>();
        values.add(1);
        cond.put("value", values);
        List<Map<String, Object>> conds = new ArrayList<>();
        conds.add(cond);
        filter.put("cond", conds);
        parameter.put("filter", filter);

        boolean fale = true;
        String zh = "";
        do {
            if (!zh.isEmpty()) {
                parameter.put("data_id", zh);
            }
            parameter.put("limit", 100);
            String jsonSale = JSONUtil.toJsonStr(parameter);
            JSONObject jdySale = ApiClient.sendPostRequest(KeyConstant.Jian_URL + "/v5/app/entry/data/list", headers, jsonSale);
            String data = jdySale.getStr("data");
            JSONArray objects = JSONUtil.parseArray(data);
            List<SalesOrder> list = JSONUtil.toList(objects, SalesOrder.class);
            if (list.size() == 100) {
                zh = list.getLast().get_id();
            } else {
                fale = false;
            }
            salesOrderList.addAll(list);
        } while (fale);

        // =====================================
        // 新增逻辑：按销售订单号分组过滤
        // =====================================
        List<SalesOrder> filteredList = new ArrayList<>();

        // 1. 按销售订单号分组
        Map<String, List<SalesOrder>> groupedByOrder = salesOrderList.stream()
                .collect(Collectors.groupingBy(SalesOrder::get_widget_1718759603973));

        // 2. 遍历每个分组
        groupedByOrder.forEach((orderNumber, orders) -> {
            if (orders.size() >= 2) { // 仅处理数据量≥2的分组
                // 3. 按审批时间排序（升序）
                List<SalesOrder> sortedOrders = orders.stream()
                        .filter(Objects::nonNull) // 过滤review_date为空的数据
                        .sorted(Comparator.comparing(SalesOrder::getReview_date))
                        .toList();

                // 4. 提取最小和最大时间的年月
                DateTime firstDate = sortedOrders.getFirst().getReview_date();
                //DateTime lastDate = sortedOrders.getLast().getReview_date();
                int minYear = firstDate.getYear();
                int minMonth = firstDate.getMonth();

                // 情况2：存在不同年月 → 排除最小年月的数据
                List<SalesOrder> validOrders = sortedOrders.stream()
                        .filter(order -> {
                            DateTime reviewDate = order.getReview_date();
                            int year = reviewDate.getYear();
                            int month = reviewDate.getMonth();
                            return !(year == minYear && month == minMonth);
                        })
                        .toList();
                filteredList.addAll(validOrders);
            }
        });
        yy1KpiMapper.truncateSalesOrderDetailsTable();
        List<SalesOrderSql> salesOrderSqlList = mergeMainAndDetails(filteredList);
        List<List<SalesOrderSql>> batches = ListUtils.partition(salesOrderSqlList, 1);
        batches.forEach(batch -> yy1KpiMapper.batchInsert(batch));
        return "success=>" + salesOrderSqlList.size();
    }
    /**
     * 将 SalesOrder 列表转换为合并后的 SaleOrderSql 列表
     * @param salesOrderList 原始销售订单列表（含明细）
     * @return 合并后的明细列表（每条包含46字段）
     */
    public static List<SalesOrderSql> mergeMainAndDetails(List<SalesOrder> salesOrderList) {
        return salesOrderList.stream()
                .flatMap(main -> main.get_widget_1718759603981().stream() // 提取明细列表
                        .map(detail -> convertToFlatEntity(main, detail)) // 主表+明细转换为单条记录
                )
                .collect(Collectors.toList());
    }
    private static SalesOrderSql convertToFlatEntity(SalesOrder main, SalesOrder.ProductDetail detail) {
        SalesOrderSql entity = new SalesOrderSql();
        // ====================== 主表字段赋值 ======================
        entity.setSalesOrderNumber(main.get_widget_1718759603973()); // 销售订单号
        entity.setOrderType(main.get_widget_1721459344897()); // 订单类型
        entity.setCustomer(main.get_widget_1718759603979()); // 客户
        entity.setCustomerReference(main.get_widget_1727494923296()); // 客户参考
        entity.setPaymentTerms(main.get_widget_1718759603989()); // 付款条件
        entity.setDocumentCurrency(main.get_widget_1718759603985()); // 凭证货币
        entity.setExchangeRate(main.get_widget_1718759603987()); // 汇率
        // 订单总数量
        entity.setTotalOrderQuantity(main.get_widget_1747038648644());
        entity.setTotalNetAmountOriginalCurrency(main.get_widget_1718759603984()); // 订单总净值（原币）
        entity.setIsLatest(main.get_widget_1725428234194()); // 是否是最新
        entity.setSalesOrderRemarks(main.get_widget_1726712474316()); // 销售订单备注
        entity.setFinalApprover(main.get_widget_1730973345880()); // 最终审核人（注意：原主表字段为 _widget_1730973344903，可能对应错误，需确认）
        entity.setIsOutStock(main.get_widget_1730952275092()); // 是否出库存
        entity.setDistributionChannel(main.get_widget_1718759603977()); // 分销渠道
        entity.setSalesOrganization(main.get_widget_1718759603976()); // 销售组织
        entity.setSalesGroup(ObjectUtils.isNotEmpty(main.get_widget_1718759603978()) ? JSONUtil.parseObj(main.get_widget_1718759603978()).getStr("name") : ""); // 销售组（Object转String）
        entity.setSalesPerson(ObjectUtils.isNotEmpty(main.get_widget_1718759603990()) ? JSONUtil.parseObj(main.get_widget_1718759603990()).getStr("name") : ""); // 业务员
        entity.setCreator(ObjectUtils.isNotEmpty(main.get_widget_1718759603983()) ? JSONUtil.parseObj(main.get_widget_1718759603983()).getStr("name") : ""); // 创建者
        entity.setOrderDate(main.get_widget_1718759603980()); // 订单日期
        entity.setDeliveryDays(main.get_widget_1721814819526()); // 交货天数
        entity.setRequiredFullDeliveryDate(main.get_widget_1718759603988()); // 要求整单交货日期
        entity.setLastApprovalModificationDate(main.getReview_date()); // 最后审批修改日期
        entity.setApprovalStatus(main.get_widget_1721620496876()); // 审批状态

        // ====================== 明细表字段赋值 ======================
        entity.setItemMaterialNumber(detail.get_widget_1718759603996()); // 行项目料号
        entity.setItemMaterialDescription(detail.get_widget_1718759603998()); // 行项目物料描述
        entity.setMaterialDetailedDescription(detail.get_widget_1718759604008()); // 物料详细描述
        entity.setSpecificationModel(detail.get_widget_1724058500073()); // 规格型号
        entity.setStyle(detail.get_widget_1724058500072()); // 款式
        entity.setItemModel(detail.get_widget_1722408396189()); // 行项目型号
        entity.setSalesOrderNumberForItem(detail.get_widget_1718759603994()); // 销售订单号（行项目关联）
        entity.setFactory(detail.get_widget_1718759604004()); // 工厂
        entity.setSalesOrderItem(detail.get_widget_1718759603995()); // 销售订单行项目
        entity.setAccessories(detail.get_widget_1724058500074()); // 配件
        entity.setPackagingMethod1(detail.get_widget_1724058500075()); // 包装方式1
        entity.setPackagingMethod2(detail.get_widget_1724038210698()); // 包装方式2
        entity.setPurchasingResponsiblePerson(ObjectUtils.isNotEmpty(detail.get_widget_1724038210699()) ? JSONUtil.parseObj(detail.get_widget_1724038210699()).getStr("name") : ""); // 采购负责人
        entity.setSalesOrderItemRemarks(detail.get_widget_1723773234761()); // 销售订单行备注
        entity.setOrderQuantity(detail.get_widget_1718759603999()); // 订单数量
        entity.setOrderUnit(detail.get_widget_1718759604000()); // 订单单位
        entity.setItemDocumentCurrency(detail.get_widget_1718759604002()); // 凭证货币（行项目）
        entity.setPriceUnit(detail.get_widget_1730353433997()); // 价格单位
        entity.setUnitPrice(detail.get_widget_1722064960629()); // 单价
        entity.setNetAmountLocalCurrencyExcludingTax(detail.get_widget_1718759604003()); // 净值（本币不含税）
        entity.setTaxAmount(detail.get_widget_1718759604007()); // 税额
        entity.setAmountIncludingTax(detail.get_widget_1721641877911()); // 含税金额
        entity.setRequestedDeliveryDate(detail.get_widget_1718759604010()); // 请求的交货日期

        // ====================== 特殊字段处理（主表与明细可能重复或需转换） ======================
        // 参考销售报价单号（主表无对应字段，从明细获取）
        entity.setSalesOrderNumberForItem(detail.get_widget_1721459344903());

        return entity;
    }

    /**
     * 查询销售订单被修改的内容及审核时间
     * @return
     */
    @GetMapping("countSalesOrderToChange")
    public String countSalesOrderToChange() {
        List<SalesOrder> salesOrderList = new ArrayList<>();
        Header[] headers = ConnmeUtils.createHeaders();
        Map<String, Object> parameter = new HashMap<>();
        parameter.put("app_id", "667230ad22a8581756b77d52");
        parameter.put("entry_id", "667230b322a8581756b78353");

        Map<String, Object> filter = new HashMap<>();
        filter.put("rel", "and");
        Map<String, Object> cond = new HashMap<>();
        cond.put("field", "flowState");
        cond.put("type", "flowstate");
        cond.put("method", "ne");
        List<Integer> values = new ArrayList<>();
        values.add(2);
        cond.put("value", values);
        List<Map<String, Object>> conds = new ArrayList<>();
        conds.add(cond);
        filter.put("cond", conds);
        parameter.put("filter", filter);

        boolean fale = true;
        String zh = "";
        do {
            if (!zh.isEmpty()) {
                parameter.put("data_id", zh);
            }
            parameter.put("limit", 100);
            String jsonSale = JSONUtil.toJsonStr(parameter);
            JSONObject jdySale = ApiClient.sendPostRequest(KeyConstant.Jian_URL + "/v5/app/entry/data/list", headers, jsonSale);
            String data = jdySale.getStr("data");
            JSONArray objects = JSONUtil.parseArray(data);
            List<SalesOrder> list = JSONUtil.toList(objects, SalesOrder.class);
            if (list.size() == 100) {
                zh = list.getLast().get_id();
            } else {
                fale = false;
            }
            salesOrderList.addAll(list);
        } while (fale);
        // 新增处理逻辑：分组、排序、计算并构建ToChangeVO
        List<ToChangeVO> toChangeVOList = new ArrayList<>();

        // 1. 按销售订单号分组（_widget_1718759603973）
        Map<String, List<SalesOrder>> orderGroupMap = salesOrderList.stream()
                .filter(order -> order.get_widget_1718759603973() != null) // 过滤订单号为空的记录
                .collect(Collectors.groupingBy(SalesOrder::get_widget_1718759603973));

        // 2. 处理每个分组
        for (Map.Entry<String, List<SalesOrder>> entry : orderGroupMap.entrySet()) {
            String orderNo = entry.getKey(); // 销售订单号
            List<SalesOrder> orderList = entry.getValue();

            // 2.1 按提交时间（createTime）升序排序（最早的在前）
            orderList.sort(Comparator.comparing(SalesOrder::getCreateTime));

            // 2.2 提取第一次提交时间（作为累计天数的基准）
            if (orderList.isEmpty()) {
                continue;
            }
            SalesOrder firstOrder = orderList.getFirst();
            DateTime firstCreateTime = firstOrder.getCreateTime();
            if (firstCreateTime == null) {
                log.warn("销售订单[{}]的第一条记录提交时间为空，跳过处理", orderNo);
                continue;
            }

            // 2.3 遍历分组内的每条记录，构建ToChangeVO
            for (int i = 0; i < orderList.size(); i++) {
                SalesOrder currentOrder = orderList.get(i);
                ToChangeVO vo = new ToChangeVO();
                vo.set_id(currentOrder.get_id()); // 使用原记录的ID

                // 构建信息字符串
                String info = buildChangeInfo(i, currentOrder, firstCreateTime);
                vo.set_widget_1751512353683(info);

                toChangeVOList.add(vo);
            }
        }

        // 3. 此处可添加将toChangeVOList插入简道云表单的逻辑
        for (ToChangeVO vo : toChangeVOList) {
            Map<String, Object> parameterInster = new HashMap<>();
            parameterInster.put("app_id", "667230ad22a8581756b77d52");
            parameterInster.put("entry_id", "667230b322a8581756b78353");
            parameterInster.put("is_start_trigger", "true");
            parameterInster.put("data_id", vo.get_id());
            vo.set_id(null);
            parameterInster.put("data", ConnmeUtils.convertEntityToMapNull(vo));
            String jsonSalee = JSONUtil.toJsonStr(parameterInster);
            ApiClient.sendPostRequest(KeyConstant.Jian_URL + "/v5/app/entry/data/update", headers, jsonSalee);
        }

        return "处理完成，共生成" + toChangeVOList.size() + "条记录";
    }

    /**
     * 构建每条修改记录的信息字符串
     * @param index 记录索引（0表示第一次提交，1表示第二次提交，以此类推）
     * @param currentOrder 当前记录
     * @param firstCreateTime 第一次提交时间（基准时间）
     * @return 格式化的信息字符串
     */
    private String buildChangeInfo(int index, SalesOrder currentOrder, DateTime firstCreateTime) {
        // 日期格式化器（转换为"yyyy年MM月dd日"）
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");

        // 转换第一次提交时间为LocalDate
        LocalDateTime firstCreateLdt = convertToLocalDateTime(firstCreateTime);
        if (firstCreateLdt == null) {
            return "时间格式错误：第一次提交时间无效";
        }

        // 处理当前记录的时间
        DateTime currentCreateTime = currentOrder.getCreateTime();
        LocalDateTime currentCreateLdt = convertToLocalDateTime(currentCreateTime);
        String currentCreateStr = currentCreateLdt != null ?
                currentCreateLdt.format(formatter) : "提交时间未知";

        DateTime currentReviewTime = currentOrder.getReview_date();
        LocalDateTime currentReviewLdt = convertToLocalDateTime(currentReviewTime);
        String currentReviewStr = currentReviewLdt != null ?
                currentReviewLdt.format(formatter) : "未审批";

        // 计算累计审批天数（第一次提交到当前审批的天数差）
        String daysDiffStr = "未知";
        if (currentReviewLdt != null) {
            long days = ChronoUnit.DAYS.between(firstCreateLdt.toLocalDate(), currentReviewLdt.toLocalDate());
            daysDiffStr = days + "天";
        }

        // 根据索引构建不同的信息
        if (index == 0) {
            // 第一次提交
            return String.format(
                    "第一次提交日期：%s；第一次审批通过时间：%s；累计审批天数：%s",
                    currentCreateStr, currentReviewStr, daysDiffStr
            );
        } else {
            // 第n次修改（n = index）
            String changeContent = currentOrder.get_widget_1727337368903() != null ?
                    currentOrder.get_widget_1727337368903() : "无修改内容";

            return String.format(
                    "第%d次修改内容：%s；第%d次提交日期：%s；第%d次审批通过时间：%s；累计审批天数：%s",
                    index, changeContent, index + 1, currentCreateStr, index + 1, currentReviewStr, daysDiffStr
            );
        }
    }

    /**
     * 将DateTime转换为LocalDateTime（处理空值和时区）
     */
    /**
     * 将 Joda-Time 的 DateTime 转换为 Java 8 的 LocalDateTime
     */
    private LocalDateTime convertToLocalDateTime(DateTime dateTime) {
        if (dateTime == null) {
            return null;
        }
        // 先格式化为字符串（确保格式与你的数据一致）
        String dateStr = dateTime.toString("yyyy-MM-dd HH:mm:ss");
        // 使用 Java 8 的 DateTimeFormatter 解析
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        return LocalDateTime.parse(dateStr, formatter);
    }
}
